home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / nose / case.py < prev    next >
Text File  |  2009-05-13  |  13KB  |  381 lines
  1. """nose unittest.TestCase subclasses. It is not necessary to subclass these
  2. classes when writing tests; they are used internally by nose.loader.TestLoader
  3. to create test cases from test functions and methods in test classes.
  4. """
  5. import logging
  6. import sys
  7. import unittest
  8. from nose.config import Config
  9. from nose.failure import Failure # for backwards compatibility
  10. from nose.util import resolve_name, test_address, try_run
  11.  
  12. log = logging.getLogger(__name__)
  13.  
  14.  
  15. __all__ = ['Test']
  16.  
  17.  
  18. class Test(unittest.TestCase):
  19.     """The universal test case wrapper.
  20.  
  21.     When a plugin sees a test, it will always see an instance of this
  22.     class. To access the actual test case that will be run, access the
  23.     test property of the nose.case.Test instance.    
  24.     """
  25.     __test__ = False # do not collect
  26.     def __init__(self, test, config=None, resultProxy=None):
  27.         # sanity check
  28.         if not callable(test):
  29.             raise TypeError("nose.case.Test called with argument %r that "
  30.                             "is not callable. A callable is required."
  31.                             % test)
  32.         self.test = test
  33.         if config is None:
  34.             config = Config()
  35.         self.config = config
  36.         self.tbinfo = None
  37.         self.capturedOutput = None
  38.         self.resultProxy = resultProxy
  39.         self.plugins = config.plugins
  40.         self.passed = None
  41.         unittest.TestCase.__init__(self)
  42.         
  43.     def __call__(self, *arg, **kwarg):
  44.         return self.run(*arg, **kwarg)
  45.  
  46.     def __str__(self):
  47.         name = self.plugins.testName(self)
  48.         if name is not None:
  49.             return name
  50.         return str(self.test)
  51.  
  52.     def __repr__(self):
  53.         return "Test(%r)" % self.test
  54.  
  55.     def afterTest(self, result):
  56.         """Called after test is complete (after result.stopTest)
  57.         """
  58.         try:
  59.             afterTest = result.afterTest
  60.         except AttributeError:
  61.             pass
  62.         else:
  63.             afterTest(self.test)
  64.  
  65.     def beforeTest(self, result):
  66.         """Called before test is run (before result.startTest)
  67.         """
  68.         try:
  69.             beforeTest = result.beforeTest
  70.         except AttributeError:
  71.             pass
  72.         else:
  73.             beforeTest(self.test)
  74.  
  75.     def exc_info(self):
  76.         """Extract exception info.
  77.         """        
  78.         exc, exv, tb = sys.exc_info()
  79.         return (exc, exv, tb)
  80.         
  81.     def id(self):
  82.         """Get a short(er) description of the test
  83.         """
  84.         return self.test.id()
  85.  
  86.     def address(self):
  87.         """Return a round-trip name for this test, a name that can be
  88.         fed back as input to loadTestByName and (assuming the same
  89.         plugin configuration) result in the loading of this test.
  90.         """
  91.         if hasattr(self.test, 'address'):
  92.             return self.test.address()
  93.         else:
  94.             # not a nose case
  95.             return test_address(self.test)
  96.  
  97.     def _context(self):
  98.         try:
  99.             return self.test.context
  100.         except AttributeError:
  101.             pass
  102.         try:
  103.             return self.test.__class__
  104.         except AttributeError:
  105.             pass
  106.         try:
  107.             return resolve_name(self.test.__module__)
  108.         except AttributeError:
  109.             pass
  110.         return None                
  111.     context = property(_context, None, None,
  112.                       """Get the context object of this test (if any).""")
  113.     
  114.     def run(self, result):
  115.         """Modified run for the test wrapper.
  116.  
  117.         From here we don't call result.startTest or stopTest or
  118.         addSuccess.  The wrapper calls addError/addFailure only if its
  119.         own setup or teardown fails, or running the wrapped test fails
  120.         (eg, if the wrapped "test" is not callable).
  121.  
  122.         Two additional methods are called, beforeTest and
  123.         afterTest. These give plugins a chance to modify the wrapped
  124.         test before it is called and do cleanup after it is
  125.         called. They are called unconditionally.
  126.         """
  127.         if self.resultProxy:
  128.             result = self.resultProxy(result, self)
  129.         try:
  130.             try:
  131.                 self.beforeTest(result)
  132.                 self.runTest(result)
  133.             except KeyboardInterrupt:
  134.                 raise
  135.             except:
  136.                 err = sys.exc_info()
  137.                 result.addError(self, err)
  138.         finally:
  139.             self.afterTest(result)
  140.         
  141.     def runTest(self, result):
  142.         """Run the test. Plugins may alter the test by returning a
  143.         value from prepareTestCase. The value must be callable and
  144.         must accept one argument, the result instance.
  145.         """        
  146.         test = self.test
  147.         plug_test = self.config.plugins.prepareTestCase(self)
  148.         if plug_test is not None:
  149.             test = plug_test
  150.         test(result)
  151.         
  152.     def shortDescription(self):
  153.         desc = self.plugins.describeTest(self)
  154.         if desc is not None:
  155.             return desc
  156.         doc = self.test.shortDescription()
  157.         if doc is not None:
  158.             return doc
  159.         # work around bug in unittest.TestCase.shortDescription
  160.         # with multiline docstrings.
  161.         test = self.test
  162.         try:
  163.             doc = test._testMethodDoc # 2.5
  164.         except AttributeError:
  165.             try:
  166.                 doc = test._TestCase__testMethodDoc # 2.4 and earlier
  167.             except AttributeError:
  168.                 pass
  169.         if doc is not None:
  170.             doc = doc.strip().split("\n")[0].strip()
  171.         return doc
  172.  
  173.  
  174. class TestBase(unittest.TestCase):
  175.     """Common functionality for FunctionTestCase and MethodTestCase.
  176.     """
  177.     __test__ = False # do not collect
  178.     
  179.     def id(self):
  180.         return str(self)
  181.         
  182.     def runTest(self):
  183.         self.test(*self.arg)
  184.     
  185.     def shortDescription(self):
  186.         if hasattr(self.test, 'description'):
  187.             return self.test.description
  188.         func, arg = self._descriptors()
  189.         doc = getattr(func, '__doc__', None)
  190.         if not doc:
  191.             doc = str(self)
  192.         return doc.strip().split("\n")[0].strip()
  193.  
  194.     
  195. class FunctionTestCase(TestBase):
  196.     """TestCase wrapper for test functions.
  197.  
  198.     Don't use this class directly; it is used internally in nose to
  199.     create test cases for test functions.
  200.     """
  201.     __test__ = False # do not collect
  202.     
  203.     def __init__(self, test, setUp=None, tearDown=None, arg=tuple(),
  204.                  descriptor=None):
  205.         """Initialize the MethodTestCase.
  206.  
  207.         Required argument:
  208.  
  209.         * test -- the test function to call.
  210.  
  211.         Optional arguments:
  212.  
  213.         * setUp -- function to run at setup.
  214.  
  215.         * tearDown -- function to run at teardown.
  216.  
  217.         * arg -- arguments to pass to the test function. This is to support
  218.           generator functions that yield arguments.
  219.  
  220.         * descriptor -- the function, other than the test, that should be used
  221.           to construct the test name. This is to support generator functions.
  222.         """
  223.         
  224.         self.test = test
  225.         self.setUpFunc = setUp
  226.         self.tearDownFunc = tearDown
  227.         self.arg = arg
  228.         self.descriptor = descriptor
  229.         TestBase.__init__(self)        
  230.  
  231.     def address(self):
  232.         """Return a round-trip name for this test, a name that can be
  233.         fed back as input to loadTestByName and (assuming the same
  234.         plugin configuration) result in the loading of this test.
  235.         """
  236.         if self.descriptor is not None:
  237.             return test_address(self.descriptor)
  238.         else:
  239.             return test_address(self.test)    
  240.  
  241.     def _context(self):
  242.         return resolve_name(self.test.__module__)
  243.     context = property(_context, None, None,
  244.                       """Get context (module) of this test""")
  245.         
  246.     def setUp(self):
  247.         """Run any setup function attached to the test function
  248.         """
  249.         if self.setUpFunc:
  250.             self.setUpFunc()
  251.         else:
  252.             names = ('setup', 'setUp', 'setUpFunc')
  253.             try_run(self.test, names)
  254.  
  255.     def tearDown(self):
  256.         """Run any teardown function attached to the test function
  257.         """
  258.         if self.tearDownFunc:
  259.             self.tearDownFunc()
  260.         else:
  261.             names = ('teardown', 'tearDown', 'tearDownFunc')
  262.             try_run(self.test, names)
  263.         
  264.     def __str__(self):
  265.         func, arg = self._descriptors()
  266.         if hasattr(func, 'compat_func_name'):
  267.             name = func.compat_func_name
  268.         else:
  269.             name = func.__name__
  270.         name = "%s.%s" % (func.__module__, name)
  271.         if arg:
  272.             name = "%s%s" % (name, arg)
  273.         # FIXME need to include the full dir path to disambiguate
  274.         # in cases where test module of the same name was seen in
  275.         # another directory (old fromDirectory)
  276.         return name 
  277.     __repr__ = __str__
  278.     
  279.     def _descriptors(self):
  280.         """Get the descriptors of the test function: the function and
  281.         arguments that will be used to construct the test name. In
  282.         most cases, this is the function itself and no arguments. For
  283.         tests generated by generator functions, the original
  284.         (generator) function and args passed to the generated function
  285.         are returned.
  286.         """
  287.         if self.descriptor:
  288.             return self.descriptor, self.arg
  289.         else:            
  290.             return self.test, self.arg
  291.  
  292.  
  293. class MethodTestCase(TestBase):
  294.     """Test case wrapper for test methods.
  295.  
  296.     Don't use this class directly; it is used internally in nose to
  297.     create test cases for test methods.
  298.     """
  299.     __test__ = False # do not collect
  300.     
  301.     def __init__(self, method, test=None, arg=tuple(), descriptor=None):
  302.         """Initialize the MethodTestCase.
  303.  
  304.         Required argument:
  305.  
  306.         * method -- the method to call, may be bound or unbound. In either
  307.           case, a new instance of the method's class will be instantiated to
  308.           make the call.
  309.  
  310.         Optional arguments:
  311.  
  312.         * test -- the test function to call. If this is passed, it will be
  313.           called instead of getting a new bound method of the same name as the
  314.           desired method from the test instance. This is to support generator
  315.           methods that yield inline functions.
  316.  
  317.         * arg -- arguments to pass to the test function. This is to support
  318.           generator methods that yield arguments.
  319.  
  320.         * descriptor -- the function, other than the test, that should be used
  321.           to construct the test name. This is to support generator methods.
  322.         """
  323.         self.method = method
  324.         self.test = test
  325.         self.arg = arg
  326.         self.descriptor = descriptor
  327.         self.cls = method.im_class
  328.         self.inst = self.cls()
  329.         if self.test is None:
  330.             method_name = self.method.__name__
  331.             self.test = getattr(self.inst, method_name)            
  332.         TestBase.__init__(self)
  333.  
  334.     def __str__(self):
  335.         func, arg = self._descriptors()
  336.         if hasattr(func, 'compat_func_name'):
  337.             name = func.compat_func_name
  338.         else:
  339.             name = func.__name__
  340.         name = "%s.%s.%s" % (self.cls.__module__,
  341.                              self.cls.__name__,
  342.                              name)
  343.         if arg:
  344.             name = "%s%s" % (name, arg)
  345.         return name
  346.     __repr__ = __str__
  347.  
  348.     def address(self):
  349.         """Return a round-trip name for this test, a name that can be
  350.         fed back as input to loadTestByName and (assuming the same
  351.         plugin configuration) result in the loading of this test.
  352.         """
  353.         if self.descriptor is not None:
  354.             return test_address(self.descriptor)
  355.         else:
  356.             return test_address(self.method)
  357.  
  358.     def _context(self):
  359.         return self.cls
  360.     context = property(_context, None, None,
  361.                       """Get context (class) of this test""")
  362.  
  363.     def setUp(self):
  364.         try_run(self.inst, ('setup', 'setUp'))
  365.  
  366.     def tearDown(self):
  367.         try_run(self.inst, ('teardown', 'tearDown'))
  368.         
  369.     def _descriptors(self):
  370.         """Get the descriptors of the test method: the method and
  371.         arguments that will be used to construct the test name. In
  372.         most cases, this is the method itself and no arguments. For
  373.         tests generated by generator methods, the original
  374.         (generator) method and args passed to the generated method 
  375.         or function are returned.
  376.         """
  377.         if self.descriptor:
  378.             return self.descriptor, self.arg
  379.         else:
  380.             return self.method, self.arg
  381.